[//I CAN HAS LASSO?

	var: 'PDQ_ValidationKeys' = (array);
	var: 'PDQ_ValidationTags' = (map);
	
	
	
	
	/*
		       datatype: compares the submitted value against the rules allowed for each of the various datatypes
		        returns: true | false
		         inputs: alpha | alphanumeric | date | decimal | email | integer | numeric | phone | ssn | url
		   TO DO inputs: datetime | ip | ipv6 | time | zip | zipPlus4 | creditCard
	*/
	var: 'PDQ_ValidDataTypes' = 
		array(
			'Alpha',
			'AlphaNumeric',
			'Date',
			'Decimal',
			'Email',
			'Integer',
			'Numeric',
			'Phone',
			'SSN',
			'URL',
			)
		;


	iterate: $PDQ_ValidDataTypes, local: 'a_datatype';
			$PDQ_ValidationKeys->insert(#a_datatype);
	/iterate;



	/*
		PDQ_DateFromString
		
		Returns (true|false)
		
		Munges a string to turn it into a date, if it is at all possible
		
	*/
//	If: !(Lasso_TagExists: 'PDQ_DateFromString');
			define_tag:'PDQ_DateFromString', -Required='Input';
					// see if it's a valid_date
					if: valid_date(#Input);
							// it appears to be valid the way it is
							local: 'a_input' = date(#input)->Format('%Q %H:%M:%S');
							if: string(#a_input) >> '0000-00-00';
							else: string(#a_input) >> '0000';
									local: 'munged_date' = #a_input;
									#munged_date = date(#munged_date);
									#munged_date = string(#munged_date);
									#munged_date = 
										(String_ReplaceRegExp:
											#munged_date,
											-Find='0000',
											-Replace=((date)->Year(-Long)),
											)
										;
									#a_input = #munged_date;
							/if;
							return(date(#a_input));
					else;
							local: 'a_input' = #input;
							
							local('newstring'=string);
							if(#a_input >> '/');
									iterate(string(#a_input), local('a_char'));
											
											if(#a_char >> '/');
													#newstring += '-';
											else;
													#newstring += #a_char;
											/if;
									/iterate;
							/if;
							
							#newstring->size != 0 ? #a_input = date(#newstring);
							
							
							if: #a_input == 'Now';
									return(date);
							/if;
							
							if: #a_input == 'Today';
									return(PDQ_DateFromSTring(date(date->Format('%Q'))));
							/if;
							
							local: 'some_monthNumbers' = (array);
							loop(12);
									#some_monthNumbers->Insert(loop_count);
							/loop;
							local: 'some_months' = (array);
							iterate: #some_monthNumbers, local('a_num');
									local: 'this_num' = integer(date(#a_num '/15/2010')->Month());
									if: #this_num < 10;
											#this_num = string('0' + #this_num);
									/if;
									#some_months->Insert(date(#a_num '/15/2010')->Month(-Long)=#this_num);
									
									#some_months->Insert(date(#a_num '/15/2010')->Month(-Short)=#this_num);
							/iterate;
							
							
							
							
							local: 'some_dayNumbers' = (array);
							loop(7);
									#some_dayNumbers->Insert(loop_count);
							/loop;
							local: 'daysMap' = (map);
							local: 'some_days' = (array);
							iterate: #some_dayNumbers, local('a_num');
									local: 'this_num' = integer(date('01/' #a_num '/2010')->DayOfWeek());
									#some_days->Insert(date('01/' #a_num '/2010')->DayOfWeek(-Long)=#this_num);
									#daysMap->  Insert((date('01/' #a_num '/2010')->DayOfWeek(-Long)=#this_num));
									
									#some_days->Insert(date('01/' #a_num '/2010')->DayOfWeek(-Short)=#this_num);
									#daysMap->Insert((date('01/' #a_num '/2010')->DayOfWeek(-Short)=#this_num));
							/iterate;
							
							
							iterate: #some_days, local: 'a_day';
									if: #a_input == #a_day;
											local: 'a_DayNum' = #a_day->Second;
											local: 'today_DayNum' =((date)->DayOfWeek());
											local: 'tempdate' = (date);
											#tempdate->Add(-Day=#a_dayNum);
											#a_input = #tempdate;
									/if;
							/iterate;
							
							iterate: #some_days, local: 'a_day';
									if: #a_input == ('next ' #a_day->First);
											local: 'a_DayNum' = #a_day->Second;
											local: 'today_DayNum' =((date)->DayOfWeek());
											local: 'tempdate' = (date);
											#tempdate->Add(-Day=#a_dayNum);
											#a_input = #tempdate;
									/if;
							/iterate;
							
							iterate: #some_days, local: 'a_day';
									if: #a_input ==('last ' #a_day->First);
											local: 'a_DayNum' = #a_day->Second;
											local: 'today_DayNum' =((date)->DayOfWeek());
											local: 'tempdate' = (date);
											#tempdate->Subtract(-Day=#a_dayNum);
											#a_input = #tempdate;
									/if;
							/iterate;
							
							
							
							local: 'munged_date' = #a_Input;
							
							// replace any commas with nothing
							#munged_date = 
								(String_ReplaceRegExp:
									#munged_date,
									-Find='(,+)',
									-Replace='',
									)
								;
							
							// replace any / with -
							
							#munged_date = #munged_date->Split(' ');
							local: 'new_split' = array;
							iterate: #munged_date, local: 'a_member';
									if: (integer(#a_member)) > 0 && (integer(#a_member)) < 3;
											#new_split->Insert(string('0' + string(#a_member)));
									else;
											#new_split->Insert(#a_member);
									/if;
							/iterate;
							#munged_date = #new_split;
							
							#munged_date = #munged_date->Join('/');
							
							
							// replace the month
							iterate: #some_months, local: 'a_month';
									if: #a_input >> #a_month->First;
											#munged_date = 
												(String_ReplaceRegExp:
													#munged_date,
													-Find='(' #a_month->First ')',
													-Replace=#a_month->Second,
													)
												;
											local: 'a_input' = #munged_date;
											
											Loop_Abort;
									/if;
							/iterate;
							
							
							local: 'regex' = '([20|19]+\\d\\d)[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])';
							local: 'regex_delimeter' = '[- /.]';
							local: 'regex_day' = '(0[1-9]|[12][0-9]|3[01])';
							local: 'regex_month' = '(0[1-9]|1[012])';
							local: 'regex_year' = '([20|19]+\\d\\d)';
							local: 'patterns_order' = array('normal','us','uk');
							local: 'patterns' = 
								map(
									'normal'=array('year', 'month', 'day'),
									'us'=array('month', 'day', 'year'),
									'uk'=array('day', 'month', 'year')
									),
								;
								
							local: 'exit' = false;
							local: 'output' = '';
							iterate: #patterns_order, local: 'a_pattern';
									local: 'a_regex' = '';
									local: 'this_pattern' = #a_pattern;
									iterate: #patterns->Find(#this_pattern), local: 'a_subPattern';
											#a_regex += local('regex_' + #a_subPattern);
											if: loop_count < #patterns->size;
													#a_regex += #regex_delimeter;
											/if;
									/iterate;
									if: boolean(String_FindRegexp(#a_input, -Find=#a_regex));
											local: 'output' = String_FindRegexp(#a_input, -Find=#a_regex);
											#output->Remove(1);
											#output = #output->Join('/');
											local: 'this' = #output;
											if: valid_date(#output);
													// this may be our baby
													return(PDQ_DateFromString(date(#output)));
											else;
													if: #this_pattern == 'uk';
															local: 'this' = (date(String_ReplaceRegexp(#output, -Find=(#regex_day #regex_delimeter #regex_month #regex_delimeter #regex_year), -Replace='\\2/\\1/\\3')));
															return(PDQ_DateFromSTring(date(#this)));
													/if;
											/if;
											loop_abort;
									else;
									
											local: 'this' = #munged_date;
											if: valid_date(#this);
													if: string(#this) >> '0000';
															local: 'munged_date' = #this;
															#munged_date = date(#munged_date);
															#munged_date = string(#munged_date);
															#munged_date = 
																(String_ReplaceRegExp:
																	#munged_date,
																	-Find='0000',
																	-Replace=((date)->Year(-Long)),
																	)
																;
															#this = #munged_date;
													/if;
													return(PDQ_DateFromSTring(date(#this)));
											else: valid_date(#this + '/2004');
													return(PDQ_DateFromSTring(date(#this + '/2004')));
											/if;
									/if;
							/iterate;
							
							//return('found something');

							local: 'munged_date' = #this;
							#munged_date = date(#munged_date);
							#munged_date = string(#munged_date);
							#munged_date = 
								(String_ReplaceRegExp:
									#munged_date,
									-Find='0000',
									-Replace=((date)->Year(-Long)),
									)
								;
							
							
							
							// we are going to have to munge it  :(
							
							
						
							
							// normalize whitespace
							#munged_date = 
								(String_ReplaceRegExp:
									#munged_date,
									-Find='(\s+)',
									-Replace=' ',
									)
								;
							
							
							// replace the month
							iterate: #some_months, local: 'a_month';
									#munged_date = 
										(String_ReplaceRegExp:
											#munged_date,
											-Find='(' #a_month ')',
											-Replace=' ',
											)
										;
							/iterate;
							
							
							
							// replace any hyphens with slashes
							#munged_date = 
								(String_ReplaceRegExp:
									#munged_date,
									-Find='(-+)',
									-Replace='/',
									)
								;
							
							if: valid_date(#munged_date);
									return((date(#munged_date))->Format('%Q %H:%M:%S'));
							else;
									return(false);
							/if;
					/if;
					
					
			/define_tag;
//	/If;



	
	/*
		PDQ_Valid_Date
		
		Returns (true|false)
		
		Checks to see whether a supplied value is a valid date, and, if supplied, the required format
		
		
		!!! FORMAT IS NOT IMPLEMENTED AS OF 10/2/04 6:52 PM  !!!
	
	*/
	If: !(Lasso_TagExists: 'PDQ_Valid_Date');
			define_tag:'PDQ_Valid_Date', -Required='Input', -Optional='Format';
			
					// NOTE: -Format is not implemented yet
			
					// first we'll see if we have to match a certain format
/* 					if: (params) >> -Format; */
/* 							// yes, we do */
/* 							local:'a_format' = String(#Format); */
/* 							local: 'enforceFormat' = true; */
/* 							 */
/* 							// NOTE -- FORMAT IS NOT IMPLEMENTED YET, HENCE, THE OVERRIDE HERE: */
/* 							local: 'enforceFormat' = false; */
/* 					else; */
/* 							// no, any old format will do */
/* 							local: 'enforceFormat' = false; */
/* 					/if; */
					
					if: valid_date(PDQ_DateFromString(#Input));
							return(true);
					else;
							return(false);
					/if;
					
			/define_tag;
	/If;
	
	
	
	
	
	
	
	
	/*
		PDQ_Valid_MaxLength
		
		Returns (true|false)
		
		Checks to see whether a supplied value is longer than the supplied allowed value
	
		      maxLength: compares length of submitted value to maxLength
		          input: any -- casts to string before compare
		        returns: true | false
	*/
	$PDQ_ValidationKeys->insert('maxLength');
	$PDQ_ValidationTags->insert('maxLength'='PDQ_Valid_MaxLength');
	If: !(Lasso_TagExists: 'PDQ_Valid_MaxLength');
			define_tag:'PDQ_Valid_MaxLength', -Required='Input', -Required='Size';
					Local:'a_input' = String(#Input);
					Local:'a_size' = Integer(#Size);
					if: #a_input->Size <= #a_size;
							Return: true;
					else;
							Return: false;
					/if;
			/define_tag;
	/If;
	
	
	
	
	
	
	
	
	/*
		PDQ_Valid_MinLength
		
		Returns (true|false)
		
		Checks to see whether a supplied value is longer than the supplied allowed value
		
		       minValue: compares submitted value to minValue
		          input: integer | decimal | date | dateTime | time
		        returns: true | false
	*/
	$PDQ_ValidationKeys->insert('minLength');
	$PDQ_ValidationTags->insert('minLength'='PDQ_Valid_MinLength');
	If: !(Lasso_TagExists: 'PDQ_Valid_MinLength');
			define_tag:'PDQ_Valid_MinLength', -Required='Input', -Required='Size';
					Local:'a_input' = String(#Input);
					Local:'a_size' = Integer(#Size);
					if: #a_input->Size >= #a_size;
							Return: true;
					else;
							Return: false;
					/if;
			/define_tag;
	/If;
	
	
	
	
	
	
	
	
	/*
		PDQ_Valid_Numeric
		
		Returns (true|false)
		
		Checks to see whether a supplied value is numeric string
	
	*/
	If: !(Lasso_TagExists: 'PDQ_Valid_Numeric');
			define_tag:'PDQ_Valid_Numeric', -Required='Input';
					Local:'a_input' = String(#Input);
					if: (params) >> -Strict;
							iterate: #a_input, local: 'a_char';
									if: (String_IsNumeric(#a_char) == false);
											return: false;
									/if;
							/iterate;
					else;
							iterate: #a_input, local: 'a_char';
									if: #a_char != ' ';
											if: (String_IsNumeric(#a_char) == false);
													return: false;
											/if;
									/if;
							/iterate;
					/if;
					Return: true;
			/define_tag;
	/If;





	/*
		PDQ_Valid_Integer
		
		Returns (true|false)
		
		Checks to see whether a supplied value is a valid integer
	
	*/
	If: !(Lasso_TagExists: 'PDQ_Valid_Integer');
			define_tag:'PDQ_Valid_Integer', -Required='Input';
					Local:'a_input' = String(#Input);
					iterate: #a_input, local: 'a_char';
						if: (String_IsNumeric(#a_char) == false);
								return: false;
						/if;
					/iterate;
					#a_input = integer(#Input);
					
					Return(true);
			/define_tag;
	/If;






	/*
		PDQ_Valid_Decimal
		
		Returns (true|false)
		
		Checks to see whether a supplied value is a valid decimal
	
	*/
	If: !(Lasso_TagExists: 'PDQ_Valid_Decimal');
			define_tag:'PDQ_Valid_Decimal', -Required='Input';
					Local:'a_input' = String(#Input);
					iterate: #a_input, local: 'a_char';
						if: #a_char != '.';
								if: (String_IsNumeric(#a_char) == false);
										return: false;
								/if;
						/if;
					/iterate;
					#a_input = decimal(#Input);
					
					Return(true);
			/define_tag;
	/If;






	/*
		PDQ_Valid_AlphaNumeric
		
		Returns (true|false)
		
		Checks to see whether a supplied value is alhpa-numeric string
	
	*/
	If: !(Lasso_TagExists: 'PDQ_Valid_AlphaNumeric');
			define_tag:'PDQ_Valid_AlphaNumeric', -Required='Input';
					Local:'a_input' = String(#Input);
					if: (params) >> -Strict;
							iterate: #a_input, local: 'a_char';
									if: #a_char->IsAlnum == false;
											return: false;
									/if;
							/iterate;
					else;
							iterate: #a_input, local: 'a_char';
									if: #a_char != ' ';
											if: #a_char->IsAlnum == false;
													return: false;
											/if;
									/if;
							/iterate;
					/if;
					Return: true;
			/define_tag;
	/If;


	/*
		PDQ_Valid_Alpha
		
		Returns (true|false)
		
		Checks to see whether a supplied value is alphabetic-only
	
	*/
	If: !(Lasso_TagExists: 'PDQ_Valid_Alpha');
			define_tag:'PDQ_Valid_Alpha', -Required='Input';
					Local:'a_input' = String(#Input);
					if: (params) >> -Strict;
							iterate: #a_input, local: 'a_char';
									if: #a_char->IsAlpha == false;
											return: false;
									/if;
							/iterate;
					else;
							iterate: #a_input, local: 'a_char';
									if: #a_char != ' ';
											if: #a_char->IsAlpha == false;
													return: false;
											/if;
									/if;
							/iterate;
					/if;
					Return: true;
			/define_tag;
	/If;




	/*
		PDQ_Valid_MaxValue
		
		Returns (true|false)
		
		Checks to see whether a supplied value is longer than the supplied allowed value
		
		
		       maxValue: compares submitted value to maxValue, based on dataType
		          input: integer | decimal | date | dateTime | time
		        returns: true | false
	*/
	$PDQ_ValidationKeys->insert('maxValue');
	$PDQ_ValidationTags->insert('maxValue'='PDQ_Valid_MaxValue');
	If: !(Lasso_TagExists: 'PDQ_Valid_MaxValue');
			define_tag:'PDQ_Valid_MaxValue', -Required='Input', -Required='Max';
					// Max
					if: (String_IsNumeric(#Max));
							Local:'a_value' = integer(#Max);
					else: #Max->Isa: 'date';
							// max is a date
							Local:'a_value' = date(#Max);
					else: (PDQ_Valid_Date: #Max);
							// max is a date
							Local:'a_value' = date(#Max);
					else: #Max->Isa: 'string';
							// Max is a string
							if: (PDQ_Valid_Alpha: #Max, -Strict);
									// Max is not numeric
									return: 'Error - Max must be a valid date, decimal, or integer.';
							else: #Max >> '.';
									// convert to a decimal
									Local:'a_value' = decimal(#Max);
							else: (PDQ_Valid_Date: #Max);
									// convert to a date
									Local:'a_value' = date(#Max);
							else;
									Local:'a_value' = integer(#Max);
							/if;
					else: #Max->Isa: 'integer';
							Local:'a_value' = integer(#Max);
					else: #Max->Isa: 'decimal';
							Local:'a_value' = decimal(#Max);
					else;
							return: 'Error - Max must be a valid date, decimal, or integer.';
					/if;
					
					
					
					
					
					// Input
					if: (String_IsNumeric(#Input));
							Local:'a_input' = integer(#Input);
					else: boolean(PDQ_Valid_Date: #Input);
							Local:'a_input' = date(#Input);
					else: #Input->Isa: 'string';
							if: (PDQ_Valid_Alpha: #Input, -Strict);
									return(false);
							else: #Input >> '.';
									// convert to a decimal
									Local:'a_input' = decimal(#Input);
							else;
									Local:'a_input' = integer(#Input);
							/if;
					else: #Input->Isa: 'integer';
							Local:'a_input' = integer(#Input);
					else: #Input->Isa: 'decimal';
							Local:'a_input' = decimal(#Input);
					else;
							return: false;
					/if;
					
					
					if: #a_value->Isa: 'date' && #a_input->Isa: 'string';
							return(false);
					/if;
					
					if: #a_value->Isa: 'date' && #a_input->Isa: 'integer';
							return(false);
					/if;
					
					if: #a_input <= #a_value;
							Return: true;
					else;
							Return: false;
					/if;
			/define_tag;
	/If;


	/*]<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
	Valid_Phone
	
	Returns { true | false } depending upon whether the input is valid or not.
	
	 ^(\(?\d\d\d\)?)?[ -]?\d\d\d[ -]?\d\d\d\d$
	
	 ^(\(?\d\d\d\)?)?[ -]?\d\d\d[ -]?\d\d\d\d$ -- loose
	 ^(\(\d\d\d\) )?\d\d\d[ -]\d\d\d\d$ -- strict

	------------------------------------------------------------------ Chris Corwin ---->
	[*/
	If: !(Lasso_TagExists: 'PDQ_Valid_Phone');
			define_tag:'PDQ_Valid_Phone', -Required='Input';
					Local:'a_number' = (String: #Input);
					Local: 'regex_Loose' = '^(\\(?\\d\\d\\d\\)?)?[ -]?\\d\\d\\d[ -]?\\d\\d\\d\\d$';
					Local: 'regex_Strict' = '^(\\(\\d\\d\\d\\) )?\\d\\d\\d[ -]\\d\\d\\d\\d$';
					if: (params) >> -Strict;
							Local: 'a_regex' = @#regex_strict;
					else;
							Local: 'a_regex' = @#regex_loose;
					/if;
					Return: (Boolean: (String_FindRegExp: #a_number, -Find=#a_regex)->Size);
			/define_tag;
	/If;






	/*
		PDQ_Valid_SSN
		
		Returns { true | false } depending upon whether the input is valid or not.
	*/
	If: !(Lasso_TagExists: 'PDQ_Valid_SSN');
			define_tag:'PDQ_Valid_SSN', -Required='Input';
					Local:'a_number' = (String: #Input);
					if: (params) >> -Strict;
							Return: (Boolean: (String_FindRegExp: #a_number, -Find='^\\d{3}\\-\\d{2}\\-\\d{4}$')->Size);
					else;
							Return: Boolean:((String_FindRegExp: #a_number, -Find='^\\d{3}[\\-]*\\d{2}[\\-]*\\d{4}$')->Size);
					/if;
			/define_tag;
	/If;





	/*
		PDQ_Valid_Email
		
		Returns { true | false } depending upon whether the input is valid or not.
	*/
	If: !(Lasso_TagExists: 'PDQ_Valid_Email');
			define_tag:'PDQ_Valid_Email', -Required='Input';
					local: 'emailPatterns' =
						Array(
							'.+@.+\\..+$',
							'^\\w.+@\\w.+\\.[a-z]+$',
							'^\\w[-_a-z~.]+@\\w[-_a-z~.]+\\.[a-z]{2}[a-z]*$',
							'^\\w[\\w\\d]+(\\.[\\w\\d]+)*@\\w[\\w\\d]+(\\.[\\w\\d]+)*\\.[a-z]{2,7}$',
							)
						;
					local:'a_input' = String(#Input);
					
					iterate: #emailPatterns, local: 'a_pattern';
							if: boolean((String_FindRegExp: #a_input, -Find=#a_pattern)->Size);
							else;
								return(false);
							/if;
					/iterate;
					return(true);
			/define_tag;
	/If;

	If: !(Lasso_TagExists: 'PDQ_Email_Obscure');
			define_tag:'PDQ_Email_Obscure', -Required='Input';
					local:'a_input' = String(#Input);
					#a_input = string_ReplaceRegExp(#a_input,-Find='\\@', -Replace='&nbsp;(at)&nbsp;');
					#a_input = string_ReplaceRegExp(#a_input,-Find='\\.', -Replace='&nbsp;(dot)&nbsp;');
					return(#a_input);
			/define_Tag;
	/if;



	/*
		PDQ_Valid_URL
		
		Returns { true | false } depending upon whether the input is valid or not.
	*/
	If: !(Lasso_TagExists: 'PDQ_Valid_URL');
			define_tag:'PDQ_Valid_URL', -Required='Input';
					local: 'patterns' =
						Array(
							'((http|ftp|https):\\/\\/)*(([\\w-]+\\.)+)([\\w-]+)(\\?*[\\w=\\&\\ ]*)',
							)
						;
					local:'a_input' = String(#Input);
					iterate: #patterns, local: 'a_pattern';
							if: boolean((String_FindRegExp: #a_input, -Find=#a_pattern)->Size);
							else;
								return(false);
							/if;
							return(true);
					/iterate;
			/define_tag;
	/If;













	define_tag:'lw_file_exists',-priority='replace',-required='filename';
		local:'out' = false;
		protect;
			#out = (boolean: ((include_raw: #filename)->size));
		/protect;
		return: #out;
	/define_tag;

	define_tag:'mhc_decrypt_blowfish',-priority='replace';
		local:'params' = params;
	
		local:'seedling' = null;
		if: #params->(find:'-seed')->size;
			#seedling = #params->(find:'-seed')->(get:1)->value;
			#params->(remove: (#params->(findposition:'-seed')->(get:1)));
		/if;
	
		local:'encrypted_string' = null;
		if: #params->size;
			if: #params->(get:1)->type == 'pair';
				#encrypted_string = #params->(get:1)->value;
			else;
				#encrypted_string = #params->(get:1);
			/if;
		/if;
	
		protect;
			handle_error;
				return: #encrypted_string;
			/handle_error;
			return: (decrypt_blowfish: -Seed=#seedling, #encrypted_string);
		/protect;
	
	/define_tag;



	/*]
	<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
	"Define"
	
	I am similar to a "Var_Set", but have one very important
	difference: I check to see if the variable I am trying to
	set has already been defined, and I will not over-write it
	if it has.
	
	If, on the other hand, it has not been defined yet, I will
	then set it to the "Default".
	
	Example of use: 
	
	Define: -Name='myVar', -Default='myValue';
	------------------------------------------------------------->
	[*/
	If: !(Lasso_TagExists: 'Define');
			Define_Tag: 
				'Define',
				-Required='Name',
				-Required='Default'
				;
					If: !(Variable_Defined: #Name);
							Var: #Name = #Default;
					/If;
			/Define_Tag;
	/If;



]